{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "f96c141c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from collections import deque"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51bd485a",
   "metadata": {},
   "source": [
    "## 1.定义算法\n",
    "### 1.1 建立Actor和Critic网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "39da0257",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Actor(nn.Module):\n",
    "\t\n",
    "\tdef __init__(self, n_states, n_actions, hidden_dim = 256):\t\n",
    "\t\t\"\"\" 初始化Actor网络，为全连接网络\n",
    "\t\t\"\"\"\n",
    "\t\tself.l1 = nn.Linear(n_states, hidden_dim)\n",
    "\t\tself.l2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "\t\tself.l3 = nn.Linear(hidden_dim, n_actions)\n",
    "\t\n",
    "\tdef forward(self, state):\n",
    "\t\t\n",
    "\t\tx = F.relu(self.l1(state))\n",
    "\t\tx = F.relu(self.l2(x))\n",
    "\t\tx = torch.tanh(self.l3(x))\n",
    "\t\treturn x\n",
    "\n",
    "class Critic(nn.Module):\n",
    "\tdef __init__(self, n_states, n_actions, hidden_dim = 256):\n",
    "\t\t\"\"\" 初始化Critic网络，为全连接网络\n",
    "\t\t\"\"\"\n",
    "\t\tself.l1 = nn.Linear(n_states + n_actions, 256)\n",
    "\t\tself.l2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "\t\tself.l3 = nn.Linear(hidden_dim, 1)\n",
    "\n",
    "\tdef forward(self, state, action):\n",
    "\t\tsa = torch.cat([state, action], 1)\n",
    "\t\tq = F.relu(self.l1(sa))\n",
    "\t\tq = F.relu(self.l2(q))\n",
    "\t\tq = self.l3(q)\n",
    "\t\treturn q"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "446652dc",
   "metadata": {},
   "source": [
    "### 1.2 定义经验回放"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "7d1e69e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBufferQue:\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        ''' 存储transition到经验回放中\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量，则取经验回放的容量\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # 顺序采样\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else: # 随机采样\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def clear(self):\n",
    "        ''' 清空经验回放\n",
    "        '''\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "         ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b8121f6",
   "metadata": {},
   "source": [
    "### 1.3 TD3算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "c1a89624",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TD3(object):\n",
    "\tdef __init__(self,cfg):\n",
    "\t\tself.gamma = cfg.gamma # 奖励的折扣因子\n",
    "\t\tself.actor_lr = cfg.actor_lr # actor学习率\n",
    "\t\tself.critic_lr = cfg.critic_lr # critic学习率\n",
    "\t\tself.policy_noise = cfg.policy_noise\n",
    "\t\tself.noise_clip = cfg.noise_clip\n",
    "\t\tself.expl_noise = cfg.expl_noise\n",
    "\t\tself.policy_freq = cfg.policy_freq\n",
    "\t\tself.batch_size =  cfg.batch_size \n",
    "\t\tself.tau = cfg.tau\n",
    "\t\tself.sample_count = 0\n",
    "\t\tself.policy_freq = cfg.policy_freq\n",
    "\t\tself.explore_steps = cfg.explore_steps\n",
    "\t\tself.device = torch.device(cfg.device)\n",
    "\t\tself.n_actions = cfg.n_actions\n",
    "\t\tself.action_space = cfg.action_space\n",
    "\t\tself.action_scale = torch.tensor((self.action_space.high - self.action_space.low)/2, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "\t\tself.action_bias = torch.tensor((self.action_space.high + self.action_space.low)/2, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "\t\tself.actor = Actor(cfg.n_states, cfg.n_actions, hidden_dim = cfg.actor_hidden_dim).to(self.device)\n",
    "\t\tself.actor_target = Actor(cfg.n_states, cfg.n_actions, hidden_dim = cfg.actor_hidden_dim).to(self.device)\n",
    "\t\tself.actor_target.load_state_dict(self.actor.state_dict()) # 复制参数到目标网络\n",
    "\n",
    "\t\tself.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr = self.actor_lr)\n",
    "\n",
    "\t\tself.critic_1 = Critic(cfg.n_states, cfg.n_actions, hidden_dim = cfg.critic_hidden_dim).to(self.device)\n",
    "\t\tself.critic_2 = Critic(cfg.n_states, cfg.n_actions, hidden_dim = cfg.critic_hidden_dim).to(self.device)\n",
    "\t\tself.critic_1_target = Critic(cfg.n_states, cfg.n_actions, hidden_dim = cfg.critic_hidden_dim).to(self.device)\n",
    "\t\tself.critic_2_target = Critic(cfg.n_states, cfg.n_actions, hidden_dim = cfg.critic_hidden_dim).to(self.device)\n",
    "\t\tself.critic_1_target.load_state_dict(self.critic_1.state_dict()) # 复制参数到目标网络\n",
    "\t\tself.critic_2_target.load_state_dict(self.critic_2.state_dict()) # 复制参数到目标网络\n",
    "\t\t\n",
    "\t\tself.critic_1_optimizer = torch.optim.Adam(self.critic_1.parameters(), lr = self.critic_lr)\n",
    "\t\tself.critic_2_optimizer = torch.optim.Adam(self.critic_2.parameters(), lr = self.critic_lr)\n",
    "\t\tself.memory = ReplayBufferQue(cfg.buffer_size)\n",
    "\t\t# self.memory = ReplayBuffer(n_states, n_actions)\n",
    "\n",
    "\tdef sample_action(self, state):\n",
    "        ''' 采样动作\n",
    "        '''\n",
    "\t\tself.sample_count += 1\n",
    "\t\tif self.sample_count < self.explore_steps:\n",
    "\t\t\treturn self.action_space.sample()\n",
    "\t\telse:\n",
    "\t\t\tstate = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "\t\t\taction = self.actor(state)\n",
    "\t\t\taction = self.action_scale * action + self.action_bias\n",
    "\t\t\taction = action.detach().cpu().numpy()[0]\n",
    "\t\t\taction_noise = np.random.normal(0, self.action_scale.cpu().numpy()[0] * self.expl_noise, size=self.n_actions)\n",
    "\t\t\taction = (action + action_noise).clip(self.action_space.low, self.action_space.high)\n",
    "\t\t\treturn action\n",
    "\n",
    "\t@torch.no_grad()\n",
    "\tdef predict_action(self, state):\n",
    "        ''' 预测动作\n",
    "        '''\n",
    "\t\tstate = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "\t\taction = self.actor(state)\n",
    "\t\taction = self.action_scale * action + self.action_bias # 对actor计算的动作分布放缩\n",
    "\t\treturn action.detach().cpu().numpy()[0]\n",
    "\n",
    "\tdef update(self):\n",
    "\t\t# if len(self.memory) < self.batch_size:\n",
    "\t\t# \treturn\n",
    "\t\tif len(self.memory) < self.explore_steps: # 当经验回放中不满足一个批量时，不更新策略\n",
    "\t\t\treturn\n",
    "\t\tstate, action, reward, next_state, done = self.memory.sample(self.batch_size) # 从经验回放中随机采样一个批量的转移(transition)\n",
    "         # 将数据转换为tensor\n",
    "\t\tstate = torch.tensor(np.array(state), device=self.device, dtype=torch.float32)\n",
    "\t\taction = torch.tensor(np.array(action), device=self.device, dtype=torch.float32)\n",
    "\t\tnext_state = torch.tensor(np.array(next_state), device=self.device, dtype=torch.float32)\n",
    "\t\treward = torch.tensor(reward, device=self.device, dtype=torch.float32).unsqueeze(1)\n",
    "\t\tdone = torch.tensor(done, device=self.device, dtype=torch.float32).unsqueeze(1)\n",
    "\t\t# update critic\n",
    "\t\tnoise = (torch.randn_like(action) * self.policy_noise).clamp(-self.noise_clip, self.noise_clip) # 构造加入目标动作的噪声\n",
    "        # 计算加入了噪声的目标动作\n",
    "\t\tnext_action = (self.actor_target(next_state) + noise).clamp(-self.action_scale+self.action_bias, self.action_scale+self.action_bias)\n",
    "        # 计算两个critic网络对t+1时刻的状态动作对的评分，并选取更小值来计算目标q值\n",
    "\t\ttarget_q1, target_q2 = self.critic_1_target(next_state, next_action).detach(), self.critic_2_target(next_state, next_action).detach()\n",
    "\t\ttarget_q = torch.min(target_q1, target_q2)\n",
    "\t\ttarget_q = reward + self.gamma * target_q * (1 - done)\n",
    "        # 计算两个critic网络对t时刻的状态动作对的评分\n",
    "\t\tcurrent_q1, current_q2 = self.critic_1(state, action), self.critic_2(state, action)\n",
    "        # 计算均方根损失\n",
    "\t\tcritic_1_loss = F.mse_loss(current_q1, target_q)\n",
    "\t\tcritic_2_loss = F.mse_loss(current_q2, target_q)\n",
    "\t\tself.critic_1_optimizer.zero_grad()\n",
    "\t\tcritic_1_loss.backward()\n",
    "\t\tself.critic_1_optimizer.step()\n",
    "\t\tself.critic_2_optimizer.zero_grad()\n",
    "\t\tcritic_2_loss.backward()\n",
    "\t\tself.critic_2_optimizer.step()\n",
    "\t\tif self.sample_count % self.policy_freq == 0:\n",
    "            # 延迟策略更新，actor的更新频率低于critic\n",
    "\t\t\tactor_loss = -self.critic_1(state, self.actor(state)).mean()\n",
    "\t\t\tself.actor_optimizer.zero_grad()\n",
    "\t\t\tactor_loss.backward()\n",
    "\t\t\tself.actor_optimizer.step()\n",
    "            #目标网络软更新\n",
    "\t\t\tfor param, target_param in zip(self.actor.parameters(), self.actor_target.parameters()):\n",
    "\t\t\t\ttarget_param.data.copy_(self.tau * param.data + (1 - self.tau) * target_param.data)\n",
    "\t\t\tfor param, target_param in zip(self.critic_1.parameters(), self.critic_1_target.parameters()):\n",
    "\t\t\t\ttarget_param.data.copy_(self.tau * param.data + (1 - self.tau) * target_param.data)\n",
    "\t\t\tfor param, target_param in zip(self.critic_2.parameters(), self.critic_2_target.parameters()):\n",
    "\t\t\t\ttarget_param.data.copy_(self.tau * param.data + (1 - self.tau) * target_param.data)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aac5335d",
   "metadata": {},
   "source": [
    "## 2.模型训练与测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "b7a73580",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(cfg, env, agent):\n",
    "    print(\"开始训练！\")\n",
    "    rewards = [] # 记录所有回合的奖励\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        state = env.reset() # 重置环境，返回初始状态\n",
    "        ep_reward = 0 # 记录一回合内的奖励\n",
    "        for i_step in range(cfg.max_steps):\n",
    "            action = agent.sample_action(state)  # 抽样动作\n",
    "            next_state, reward, terminated, info = env.step(action)  # 更新环境，返回transitions\n",
    "            agent.memory.push((state, action, reward,\n",
    "                            next_state, terminated))  # 保存transition\n",
    "            agent.update()   # 更新智能体\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                break\n",
    "        if (i_ep+1)%10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}\")\n",
    "        rewards.append(ep_reward)\n",
    "    print(\"完成训练！\")\n",
    "    return {'rewards':rewards}\n",
    "def test(cfg, env, agent):\n",
    "    print(\"开始测试！\")\n",
    "    rewards = [] # 记录所有回合的奖励\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        state = env.reset() # 重置环境，返回初始状态\n",
    "        ep_reward = 0 # 记录一回合内的奖励\n",
    "        for i_step in range(cfg.max_steps):\n",
    "            action = agent.sample_action(state)  # 抽样动作\n",
    "            next_state, reward, terminated, info = env.step(action)  # 更新环境，返回transitions\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        print(f\"回合：{i_ep+1}/{cfg.test_eps}，奖励：{ep_reward:.2f}\")\n",
    "    print(\"完成测试！\")\n",
    "    return {'rewards':rewards}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d9e3b7b",
   "metadata": {},
   "source": [
    "## 3.定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "90b2350f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import os\n",
    "def all_seed(env,seed = 1):\n",
    "    ''' 万能的seed函数\n",
    "    '''\n",
    "    env.seed(seed) # env config\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False\n",
    "def env_agent_config(cfg):\n",
    "    env = gym.make(cfg.env_name) # 创建环境\n",
    "    all_seed(env,seed=cfg.seed)\n",
    "    n_states = env.observation_space.shape[0]\n",
    "    n_actions = env.action_space.shape[0]\n",
    "    print(f\"状态空间维度：{n_states}，动作空间维度：{n_actions}\")\n",
    "    # 更新n_states和n_actions到cfg参数中\n",
    "    setattr(cfg, 'n_states', n_states)\n",
    "    setattr(cfg, 'n_actions', n_actions) \n",
    "    setattr(cfg, 'action_space', env.action_space) \n",
    "    models = {\"actor\":Actor(n_states,n_actions,hidden_dim=cfg.actor_hidden_dim),\"critic\":Critic(n_states,n_actions,hidden_dim=cfg.critic_hidden_dim)}\n",
    "    memory = ReplayBufferQue(cfg.buffer_size) # 创建经验池\n",
    "    agent = TD3(cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2dedbaf",
   "metadata": {},
   "source": [
    "## 4.设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "06d5035c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "class Config:\n",
    "    def __init__(self):\n",
    "        self.algo_name = 'TD3' # 算法名称\n",
    "        self.env_name = 'Pendulum-v1' # 环境名称\n",
    "        self.device = \"cpu\" # 使用设备\n",
    "        self.train_eps = 100 # 训练迭代次数\n",
    "        self.test_eps = 20 # 测试迭代次数\n",
    "        self.eval_eps = 10 # 评估迭代次数\n",
    "        self.eval_per_episode = 5 # 每隔几代评估\n",
    "        self.max_steps = 200 # 每次迭代最大时间步\n",
    "        self.policy_freq = 2  # 策略网络更新频率\n",
    "        self.actor_lr = 1e-3 \n",
    "        self.critic_lr = 1e-3 \n",
    "        self.actor_hidden_dim = 256 # actor网络隐藏层维度\n",
    "        self.critic_hidden_dim = 256 # critic网络隐藏层维度\n",
    "        self.gamma = 0.99 \n",
    "        self.tau = 0.005 # 目标网络软更新系数\n",
    "        self.policy_noise = 0.2 # 加入策略网络的噪声\n",
    "        self.expl_noise = 0.1 # 高斯噪声标准差\n",
    "        self.noise_clip = 0.5 # 加入策略网络噪声范围\n",
    "        self.batch_size = 100 # 训练批次大小\n",
    "        self.buffer_size = 1000000 # 经验回放池大小\n",
    "def smooth(data, weight=0.9):  \n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(rewards,title=\"learning curve\"):\n",
    "    sns.set()\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{title}\")\n",
    "    plt.xlim(0, len(rewards), 10)  # 设置x轴的范围\n",
    "    plt.xlabel('epsiodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c951326",
   "metadata": {},
   "source": [
    "## 5.开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "9d95733d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "状态空间维度：3，动作空间维度：1\n",
      "开始训练！\n",
      "回合：10/100，奖励：-1357.86\n",
      "回合：20/100，奖励：-1507.25\n",
      "回合：30/100，奖励：-125.20\n",
      "回合：40/100，奖励：-442.47\n",
      "回合：50/100，奖励：-239.14\n",
      "回合：60/100，奖励：-133.72\n",
      "回合：70/100，奖励：-365.47\n",
      "回合：80/100，奖励：-261.53\n",
      "回合：90/100，奖励：-232.35\n",
      "回合：100/100，奖励：-395.64\n",
      "完成训练！\n",
      "开始测试！\n",
      "回合：1/20，奖励：-120.54\n",
      "回合：2/20，奖励：-124.10\n",
      "回合：3/20，奖励：-127.38\n",
      "回合：4/20，奖励：-319.82\n",
      "回合：5/20，奖励：-1.56\n",
      "回合：6/20，奖励：-118.70\n",
      "回合：7/20，奖励：-262.54\n",
      "回合：8/20，奖励：-241.95\n",
      "回合：9/20，奖励：-233.77\n",
      "回合：10/20，奖励：-225.01\n",
      "回合：11/20，奖励：-276.40\n",
      "回合：12/20，奖励：-232.85\n",
      "回合：13/20，奖励：-228.15\n",
      "回合：14/20，奖励：-1.62\n",
      "回合：15/20，奖励：-122.91\n",
      "回合：16/20，奖励：-120.06\n",
      "回合：17/20，奖励：-1.60\n",
      "回合：18/20，奖励：-247.22\n",
      "回合：19/20，奖励：-121.09\n",
      "回合：20/20，奖励：-1.69\n",
      "完成测试！\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \n",
    "# 训练\n",
    "env, agent = env_agent_config(cfg)\n",
    "res_dic = train(cfg, env, agent)\n",
    " \n",
    "plot_rewards(res_dic['rewards'], title=f\"training curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")  \n",
    "# 测试\n",
    "res_dic = test(cfg, env, agent)\n",
    "plot_rewards(res_dic['rewards'], title=f\"testing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")  # 画出结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a85e859e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e36f40ad",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (tensorflowenv)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
